关闭

速度之王 — LZ4压缩算法(三)

标签: 压缩算法
11976人阅读 评论(1) 收藏 举报
分类:

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的优势在于压缩和解压速度,而不是压缩比。

 

 

3
0
查看评论
发表评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场

速度之王 — LZ4压缩算法(一)

LZ4是一个快速的无损压缩算法,单核的压缩速度超过400MB/s,单核的解压速度超过1GB/s。 LZ4也适用于多核的情况,压缩速度能成倍的提高,解压速度几乎达到RAM的速度限制。 文本主要分析LZ4...
  • zhangskd
  • zhangskd
  • 2013-12-19 17:35
  • 53506

几种压缩算法的压缩和速度比较 LZ4太快了

Quick Benchmark: Gzip vs Bzip2 vs LZMA vs XZ vs LZ4 vs LZO EDIT: Add zstd Conten...
  • leilonghao
  • leilonghao
  • 2017-06-14 10:11
  • 4140

速度之王 — LZ4压缩算法(二)

LZ4是一个快速的无损压缩算法,单核的压缩速度超过400MB/s,单核的解压速度超过1GB/s。 LZ4也适用于多核的情况,压缩速度能成倍的提高,解压速度几乎达到RAM的速度限制。 文本主要分析LZ4...
  • zhangskd
  • zhangskd
  • 2013-12-19 17:44
  • 16214

几款主流的压缩算法对比Zlib,snappy,lz4

几款主流的压缩算法对比Zlib,snappy,lz4 TODO .... https://github.com/Cyan4973/lz4 http://cyan4973.github.io/lz4/...
  • jiangguilong2000
  • jiangguilong2000
  • 2015-11-19 18:39
  • 6523

lz4: 性能很好的压缩算法

最近在不少项目特别是存储相关的项目用到了lz4压缩算法,它有什么特点呢? LZ4 is a very fast lossless compression algorithm, providing...
  • abv123456789
  • abv123456789
  • 2013-05-12 15:59
  • 3009

lz4压缩算法源码

  • 2016-01-21 19:41
  • 131KB
  • 下载

LZ4压缩算法集合包

  • 2016-06-25 09:41
  • 1.56MB
  • 下载

速度之王 — LZ4压缩算法

LZ4 (Extremely Fast Compression algorithm) 项目:http://code.google.com/p/lz4/ 作者:Yann Collet 本文作者:z...
  • WHACKW
  • WHACKW
  • 2015-08-05 16:42
  • 1883

使用Python和C#对比跨语言压缩算法库LZ4, Snappy, LZO, gzip, glib

写在前面:     在游戏编程中,数据的处理部分,经常会遇到这样的需求:     1,服务器端(后端)传给客户端(前端)的数据需要压缩,以节省流量,加速游戏数据通信效率。     2,这种压缩/解压算...
  • chenggong2dm
  • chenggong2dm
  • 2017-04-14 12:37
  • 1856

LZ4极速压缩

  • 2016-01-04 08:22
  • 60KB
  • 下载
    个人资料
    • 访问:1446505次
    • 积分:12703
    • 等级:
    • 排名:第1269名
    • 原创:150篇
    • 转载:8篇
    • 译文:0篇
    • 评论:223条
    博客专栏
    博客公告

    小程序员一个,坐标深圳。

    Email: zhangskd at gmail.com

    不总在,多包涵

    最新评论