LZ4算法使用

已于 2024-07-17 12:51:59 修改
阅读量341 收藏 9
点赞数 4
分类专栏： 周问周答 文章标签： 算法
于 2024-07-01 10:10:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16106195/article/details/140093549
版权

LZ4下载编译

LZ4 是无损压缩算法，提供每个核 大于 500 MB/s 的压缩速度，可通过多核 CPU 进行扩展。LZ4算法解压速度极快，单核解压速度达到GB/s，通常达到多核系统的 RAM 速度极限。

$ git clone https://github.com/lz4/lz4.git
make 
make install

lz4算法的实现在lib下，lz4.c实现最基本的块格式压缩和解压，lz4hc.c实现块高压缩率的块格式压缩和解压，lz4frame.c实现帧格式压缩和解压，为了方便lz4file.c实现文件压缩解压操作，xxhash.c是LZ4采用的哈希算法。

$ tree lib
lib
├── lz4.c
├── lz4.h
├── lz4file.c
├── lz4file.h
├── lz4frame.c
├── lz4frame.h
├── lz4frame_static.h
├── lz4hc.c
├── lz4hc.h
├── xxhash.c
├── xxhash.h

lz4命令行使用如下：

$ lz4 -h
*** LZ4 command line interface 64-bits v1.9.2, by Yann Collet ***
Usage : 
      lz4 [arg] [input] [output] 

input   : a filename 
          with no FILE, or when FILE is - or stdin, read standard input
Arguments : 
 -1     : Fast compression (default) 
 -9     : High compression 
 -d     : decompression (default for .lz4 extension)
 -z     : force compression 
 -D FILE: use FILE as dictionary 
 -f     : overwrite output without prompting 
 -k     : preserve source files(s)  (default) 
--rm    : remove source file(s) after successful de/compression 
 -h/-H  : display help/long help and exit 

Advanced arguments :
 -V     : display Version number and exit 
 -v     : verbose mode 
 -q     : suppress warnings; specify twice to suppress errors too
 -c     : force write to standard output, even if it is the console
 -t     : test compressed file integrity
 -m     : multiple input files (implies automatic output filenames)
 -r     : operate recursively on directories (sets also -m) 
 -l     : compress using Legacy format (Linux kernel compression)
 -B#    : cut file into blocks of size # bytes [32+] 
                     or predefined block size [4-7] (default: 7) 
 -BI    : Block Independence (default) 
 -BD    : Block dependency (improves compression ratio) 
 -BX    : enable block checksum (default:disabled) 
--no-frame-crc : disable stream checksum (default:enabled) 
--content-size : compressed frame includes original size (default:not present)
--list FILE : lists information about .lz4 files (useful for files compressed with --content-size flag)
--[no-]sparse  : sparse mode (default:enabled on file, disabled on stdout)
--favor-decSpeed: compressed files decompress faster, but are less compressed 
--fast[=#]: switch to ultra fast compression level (default: 1)
--best  : same as -12
Benchmark arguments : 
 -b#    : benchmark file(s), using # compression level (default : 1) 
 -e#    : test all compression levels from -bX to # (default : 1)
 -i#    : minimum evaluation time in seconds (default : 3s)

使用示例

块格式

LZ4块格式压缩和解压的函数为：LZ4_compress_default和LZ4_decompress_safe。测试代码如下：

int lz4_block_compress_test(void)
{
    int ret;
	const char msg[] = "hello david, hello lily, hello tom, hello lucy, hello bob";

	// 块block格式
	const char expected_compressed_data[] = {
		0xd2, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x64, 0x61, 0x76, 0x69, 0x64, 0x2c, 0x20, 0x0d, 0x00, 
		0x44, 0x6c, 0x69, 0x6c, 0x79, 0x0c, 0x00, 0x34, 0x74, 0x6f, 0x6d, 0x0b, 0x00, 0x33, 0x6c, 0x75, 
		0x63, 0x17, 0x00, 0x50, 0x6f, 0x20, 0x62, 0x6f, 0x62
	};	
	char buf[64] = {0};

	// 压缩
    ret = LZ4_compress_default(msg, buf, strlen(msg), sizeof(buf));
    if (ret <= 0) {
        printf("Failed to compresss data, ret=%d\n", ret);
        return -1;
    }
    if (ret != sizeof(expected_compressed_data) || \
            memcmp(buf, expected_compressed_data, sizeof(expected_compressed_data)) != 0) {
        printf("Compresss data is not expected\n");
        return -1;
    }
    hexdump("Compress data", buf, ret);
    

    // 解压
	ret = LZ4_decompress_safe(expected_compressed_data, buf, sizeof(expected_compressed_data), sizeof(buf));
    if (ret <= 0) {
        printf("Failed to decompresss data, ret=%d\n", ret);
        return -1;
    }
    if (ret != strlen(msg) || \
            memcmp(buf, msg, strlen(msg)) != 0) {
        printf("Decompresss data is not expected\n");
        return -1;
    }
    printf("Deompress data: %.*s\n", ret, buf);

	return ret;    
}

Linux kernel块格式

由于下一节帧格式解压需要依赖动态内存分配，因此linux kernel的自解压代码也是采用帧格式形式，只是在压缩数据最前面添加了4字节的压缩魔法数0x184C2102和4字节压缩后的数据长度。

$ echo -n "hello david, hello lily, hello tom, hello lucy, hello bob" > hello
# 注意使用-l参数，Linux kernel compression
$ lz4 -l -f -v hello
$ hexdump -C hello.lz4
00000000  02 21 4c 18 29 00 00 00  d2 68 65 6c 6c 6f 20 64  |.!L.)....hello d|
00000010  61 76 69 64 2c 20 0d 00  44 6c 69 6c 79 0c 00 34  |avid, ..Dlily..4|
00000020  74 6f 6d 0b 00 33 6c 75  63 17 00 50 6f 20 62 6f  |tom..3luc..Po bo|
00000030  62                                                |b|
00000031

测试代码如下：

int lz4_block_compress_kernel_format_test(void)
{
    int ret, chunksize;
	const char msg[] = "hello david, hello lily, hello tom, hello lucy, hello bob";

	// 块block格式(linux kernel format)
	const char expected_compressed_data[] = {
        0x02, 0x21, 0x4c, 0x18, 0x29, 0x00, 0x00, 0x00, 0xd2, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x64, 
        0x61, 0x76, 0x69, 0x64, 0x2c, 0x20, 0x0d, 0x00, 0x44, 0x6c, 0x69, 0x6c, 0x79, 0x0c, 0x00, 0x34, 
        0x74, 0x6f, 0x6d, 0x0b, 0x00, 0x33, 0x6c, 0x75, 0x63, 0x17, 0x00, 0x50, 0x6f, 0x20, 0x62, 0x6f, 
        0x62
	};	
	char buf[64] = {0};

	// 写入魔法数
    PUT_UINT32_LE(ARCHIVE_MAGICNUMBER, buf, 0);
    // 压缩
    ret = LZ4_compress_default(msg, buf + 8, strlen(msg), sizeof(buf) - 8);
    if (ret <= 0) {
        printf("Failed to compresss data, ret=%d\n", ret);
        return -1;
    }
    // 写入压缩后的数据长度
    chunksize = ret;
    PUT_UINT32_LE(chunksize, buf, 4);
    if (ret + 8 != sizeof(expected_compressed_data) || \
            memcmp(buf, expected_compressed_data, sizeof(expected_compressed_data)) != 0) {
        printf("Compresss data is not expected\n");
        return -1;
    }
    hexdump("Compress data", buf, ret + 8);

    // 读取魔法数
	chunksize = GET_UINT32_LE(expected_compressed_data, 0);
	if (chunksize != ARCHIVE_MAGICNUMBER) {
		printf("Invalid header\n");
		return -1;
	}
    // 读取压缩后的数据长度
    chunksize = GET_UINT32_LE(expected_compressed_data, 4);
    // 解压
	ret = LZ4_decompress_safe(expected_compressed_data + 8, buf, chunksize, sizeof(buf));
    if (ret <= 0) {
        printf("Failed to decompresss data, ret=%d\n", ret);
        return -1;
    }
    if (ret != strlen(msg) || \
            memcmp(buf, msg, strlen(msg)) != 0) {
        printf("Decompresss data is not expected\n");
        return -1;
    }
    printf("Deompress data: %.*s\n", ret, buf);

	return ret;    
}

帧格式

LZ4帧格式压缩和解压的函数为：LZ4F_compressFrame和LZ4F_decompress。测试代码如下：

int lz4_frame_compress_test(void)
{
    int ret;
	const char msg[] = "hello david, hello lily, hello tom, hello lucy, hello bob";

	// 帧frame格式
	const char expected_compressed_data[] = {
		0x04, 0x22, 0x4d, 0x18, 0x64, 0x40, 0xa7, 0x29, 0x00, 0x00, 0x00, 0xd2, 0x68, 0x65, 0x6c, 0x6c, 
        0x6f, 0x20, 0x64, 0x61, 0x76, 0x69, 0x64, 0x2c, 0x20, 0x0d, 0x00, 0x44, 0x6c, 0x69, 0x6c, 0x79, 
        0x0c, 0x00, 0x34, 0x74, 0x6f, 0x6d, 0x0b, 0x00, 0x33, 0x6c, 0x75, 0x63, 0x17, 0x00, 0x50, 0x6f, 
        0x20, 0x62, 0x6f, 0x62, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x04, 0x5b, 0x61
	};	
	char buf[64] = {0};

	// 压缩
    LZ4F_preferences_t pref = LZ4F_INIT_PREFERENCES;
    pref.frameInfo.contentChecksumFlag = LZ4F_contentChecksumEnabled; //使能C.Checksum
    size_t bound_size = LZ4F_compressFrameBound(strlen(msg), &pref);
    ret = LZ4F_compressFrame(buf, bound_size, msg, strlen(msg), &pref);
    if (LZ4F_isError(ret)) {
        printf("Failed to compresss data, err=%d\n", LZ4F_isError(ret));
        return -1;
    }
    if (ret != sizeof(expected_compressed_data) || \
            memcmp(buf, expected_compressed_data, sizeof(expected_compressed_data)) != 0) {
        printf("Compresss data is not expected\n");
        return -1;
    }
    hexdump("Compress data", buf, ret);

    // 解压
    LZ4F_dctx* dctx;
    size_t in_len = sizeof(expected_compressed_data);
    size_t out_len = sizeof(buf);    
    ret = LZ4F_createDecompressionContext(&dctx, LZ4F_VERSION);
	if (LZ4F_isError(ret)) {
		printf("Decompress context creation err=%d\n", LZ4F_isError(ret));
		return -1;
	}    
	ret = LZ4F_decompress(dctx, buf, &out_len, expected_compressed_data, &in_len, NULL);
    if (LZ4F_isError(ret)) {
        printf("Failed to decompresss data, err=%d\n", LZ4F_isError(ret));
        goto exit;
    }
    if (memcmp(buf, msg, strlen(msg)) != 0) {
        printf("Decompresss data is not expected\n");
    }
    printf("Deompress data: %.*s\n", (uint32_t)strlen(msg), buf);
exit:
    LZ4F_freeDecompressionContext(dctx);
	return ret;    
}

完整代码

#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "lz4.h"
#include "lz4frame.h"

static void hexdump(const char *name, const uint8_t *buffer, size_t len)
{
    printf("****************%s****************\n", name);
    for (uint16_t i = 0; i < len; i++) {
        printf("%02x ", buffer[i]);
        if ((i + 1) % 16 == 0) {
            printf("\n");
        }
    }
    if (len % 16 ) {
        printf("\n");
    }
}

int lz4_block_compress_test(void)
{
    int ret;
	const char msg[] = "hello david, hello lily, hello tom, hello lucy, hello bob";

	// 块block格式
	const char expected_compressed_data[] = {
		0xd2, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x64, 0x61, 0x76, 0x69, 0x64, 0x2c, 0x20, 0x0d, 0x00, 
		0x44, 0x6c, 0x69, 0x6c, 0x79, 0x0c, 0x00, 0x34, 0x74, 0x6f, 0x6d, 0x0b, 0x00, 0x33, 0x6c, 0x75, 
		0x63, 0x17, 0x00, 0x50, 0x6f, 0x20, 0x62, 0x6f, 0x62
	};	
	char buf[64] = {0};

	// 压缩
    ret = LZ4_compress_default(msg, buf, strlen(msg), sizeof(buf));
    if (ret <= 0) {
        printf("Failed to compresss data, ret=%d\n", ret);
        return -1;
    }
    if (ret != sizeof(expected_compressed_data) || \
            memcmp(buf, expected_compressed_data, sizeof(expected_compressed_data)) != 0) {
        printf("Compresss data is not expected\n");
        return -1;
    }
    hexdump("Compress data", buf, ret);
    

    // 解压
	ret = LZ4_decompress_safe(expected_compressed_data, buf, sizeof(expected_compressed_data), sizeof(buf));
    if (ret <= 0) {
        printf("Failed to decompresss data, ret=%d\n", ret);
        return -1;
    }
    if (ret != strlen(msg) || \
            memcmp(buf, msg, strlen(msg)) != 0) {
        printf("Decompresss data is not expected\n");
        return -1;
    }
    printf("Deompress data: %.*s\n", ret, buf);

	return ret;    
}


#ifndef PUT_UINT32_LE
#define PUT_UINT32_LE( n, data, offset )                        \
{                                                               \
    ( data )[( offset )    ] = (uint8_t) ( (n)       );         \
    ( data )[( offset ) + 1] = (uint8_t) ( (n) >> 8  );         \
    ( data )[( offset ) + 2] = (uint8_t) ( (n) >> 16 );         \
    ( data )[( offset ) + 3] = (uint8_t) ( (n) >> 24 );         \
}
#endif

#ifndef GET_UINT32_LE
#define GET_UINT32_LE( data , offset )                          \
    (                                                           \
          ( (uint32_t) ( data )[( offset )    ] 	  )         \
        | ( (uint32_t) ( data )[( offset ) + 1] << 8  )         \
        | ( (uint32_t) ( data )[( offset ) + 2] << 16 )         \
        | ( (uint32_t) ( data )[( offset ) + 3] << 24 )         \
    )
#endif

#define ARCHIVE_MAGICNUMBER 0x184C2102

int lz4_block_compress_kernel_format_test(void)
{
    int ret, chunksize;
	const char msg[] = "hello david, hello lily, hello tom, hello lucy, hello bob";

	// 块block格式(linux kernel format)
	const char expected_compressed_data[] = {
        0x02, 0x21, 0x4c, 0x18, 0x29, 0x00, 0x00, 0x00, 0xd2, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x64, 
        0x61, 0x76, 0x69, 0x64, 0x2c, 0x20, 0x0d, 0x00, 0x44, 0x6c, 0x69, 0x6c, 0x79, 0x0c, 0x00, 0x34, 
        0x74, 0x6f, 0x6d, 0x0b, 0x00, 0x33, 0x6c, 0x75, 0x63, 0x17, 0x00, 0x50, 0x6f, 0x20, 0x62, 0x6f, 
        0x62
	};	
	char buf[64] = {0};

	// 写入魔法数
    PUT_UINT32_LE(ARCHIVE_MAGICNUMBER, buf, 0);
    // 压缩
    ret = LZ4_compress_default(msg, buf + 8, strlen(msg), sizeof(buf) - 8);
    if (ret <= 0) {
        printf("Failed to compresss data, ret=%d\n", ret);
        return -1;
    }
    // 写入压缩后的数据长度
    chunksize = ret;
    PUT_UINT32_LE(chunksize, buf, 4);
    if (ret + 8 != sizeof(expected_compressed_data) || \
            memcmp(buf, expected_compressed_data, sizeof(expected_compressed_data)) != 0) {
        printf("Compresss data is not expected\n");
        return -1;
    }
    hexdump("Compress data", buf, ret + 8);

    // 读取魔法数
	chunksize = GET_UINT32_LE(expected_compressed_data, 0);
	if (chunksize != ARCHIVE_MAGICNUMBER) {
		printf("Invalid header\n");
		return -1;
	}
    // 读取压缩后的数据长度
    chunksize = GET_UINT32_LE(expected_compressed_data, 4);
    // 解压
	ret = LZ4_decompress_safe(expected_compressed_data + 8, buf, chunksize, sizeof(buf));
    if (ret <= 0) {
        printf("Failed to decompresss data, ret=%d\n", ret);
        return -1;
    }
    if (ret != strlen(msg) || \
            memcmp(buf, msg, strlen(msg)) != 0) {
        printf("Decompresss data is not expected\n");
        return -1;
    }
    printf("Deompress data: %.*s\n", ret, buf);

	return ret;    
}


int lz4_frame_compress_test(void)
{
    int ret;
	const char msg[] = "hello david, hello lily, hello tom, hello lucy, hello bob";

	// 帧frame格式
	const char expected_compressed_data[] = {
		0x04, 0x22, 0x4d, 0x18, 0x64, 0x40, 0xa7, 0x29, 0x00, 0x00, 0x00, 0xd2, 0x68, 0x65, 0x6c, 0x6c, 
        0x6f, 0x20, 0x64, 0x61, 0x76, 0x69, 0x64, 0x2c, 0x20, 0x0d, 0x00, 0x44, 0x6c, 0x69, 0x6c, 0x79, 
        0x0c, 0x00, 0x34, 0x74, 0x6f, 0x6d, 0x0b, 0x00, 0x33, 0x6c, 0x75, 0x63, 0x17, 0x00, 0x50, 0x6f, 
        0x20, 0x62, 0x6f, 0x62, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x04, 0x5b, 0x61
	};	
	char buf[64] = {0};

	// 压缩
    LZ4F_preferences_t pref = LZ4F_INIT_PREFERENCES;
    pref.frameInfo.contentChecksumFlag = LZ4F_contentChecksumEnabled;
    size_t bound_size = LZ4F_compressFrameBound(strlen(msg), &pref);
    ret = LZ4F_compressFrame(buf, bound_size, msg, strlen(msg), &pref);
    if (LZ4F_isError(ret)) {
        printf("Failed to compresss data, err=%d\n", LZ4F_isError(ret));
        return -1;
    }
    if (ret != sizeof(expected_compressed_data) || \
            memcmp(buf, expected_compressed_data, sizeof(expected_compressed_data)) != 0) {
        printf("Compresss data is not expected\n");
        return -1;
    }
    hexdump("Compress data", buf, ret);

    // 解压
    LZ4F_dctx* dctx;
    size_t in_len = sizeof(expected_compressed_data);
    size_t out_len = sizeof(buf);    
    ret = LZ4F_createDecompressionContext(&dctx, LZ4F_VERSION);
	if (LZ4F_isError(ret)) {
		printf("Decompress context creation err=%d\n", LZ4F_isError(ret));
		return -1;
	}    
	ret = LZ4F_decompress(dctx, buf, &out_len, expected_compressed_data, &in_len, NULL);
    if (LZ4F_isError(ret)) {
        printf("Failed to decompresss data, err=%d\n", LZ4F_isError(ret));
        goto exit;
    }
    if (memcmp(buf, msg, strlen(msg)) != 0) {
        printf("Decompresss data is not expected\n");
    }
    printf("Deompress data: %.*s\n", (uint32_t)strlen(msg), buf);
exit:
    LZ4F_freeDecompressionContext(dctx);
	return ret;    
}

int main(int argc, char* argv[])
{
    // 块格式压缩解压测试
    lz4_block_compress_test();
    // linux kernel形式的块压缩解压测试
    lz4_block_compress_kernel_format_test();
    // 帧格式压缩解压测试
    lz4_frame_compress_test();

    return 0;
}

编译，并运行测试：

$ gcc -g main.c lz4.c lz4frame.c lz4hc.c xxhash.c -o main
$ ./main

各种压缩算法对比

以kernel采用的各种解压算法为例，原始镜像Image大小为6M左右，在开发板上，CPU速率为1GHz，实际测试的数据如下表。

算法压缩率解压时间
lz464.68%28ms
gzip55.73%155ms
lzma44.33%1722ms
xz44.16%1034ms
lzo60.98%48ms

可以看出，lz4算法在压缩率和解压时间综合表现较好。

欢迎关注“安全有理”微信公众号。

安全有理

安全有理
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ElasticSearch中压缩算法LZ4的使用
qq_29579431的博客
01-21 3472
简介 lz4是目前效率最高的压缩算法，更加侧重压缩解压速度，而不是压缩比。LZ4是ElasticSearch数据存储的默认编码（压缩）方式，通过index.codec来设置。 压缩原理 lz4压缩算法原理比较简单，如下面例子： 输入：abcde_bcdefgh_abcdefghxxxxxxx 输出：abcde_(5,4)fgh_(14,5)fghxxxxxxx 其中两个括号内的便代表的是压缩时检测到的重复项，(5,4) 代表向前5个byte，匹配到的内容长度有4，即"bcde"是一个重复。当然也可以说"c
lz4：极快压缩算法
02-04
LZ4-极快的压缩 LZ4是无损压缩算法，提供每核心大于500 MB / s的压缩速度，可通过多核CPU进行扩展。 它具有极快的解码器，每个内核的速度为多个GB / s，通常在多内核系统上达到RAM速度限制。 速度可以动态调整，选择一个“加速”因数，以权衡压缩比以获得更快的速度。 另一方面，还提供了高压缩导数LZ4_HC，以CPU时间为代价来提高压缩率。 所有版本均具有相同的减压速度。 LZ4还与和级别的兼容。 尽管仅使用最后的64KB，但它可以将任何输入文件作为字典接收。 该功能可以与结合使用，以大大提高小文件的压缩性能。 LZ4库作为使用BSD 2条款许可证的开源软件提供。 科 状
使用LZ4对内存中的数字向量进行非常快速的压缩/解压缩-C/C++开发
05-27
lz4lite提供对lz4中极其快速的压缩的访问，以执行内存中压缩。 lz4lite lz4lite提供对lz4中极其快速的压缩的访问，以执行内存中压缩。 此程序包的范围是有限的-它旨在提供用于直接散列包含原始，整数，实数，复数或逻辑值的向量的函数。 它通过对向量内的数据有效载荷进行操作来实现此目的，并且通过不对R对象本身进行序列化来显着提高速度。 如果要压缩任意R对象，则必须首先手动将其转换为原始vecto
Lz4的编译和使用
yuxikuo_1的专栏
03-18 7549
Lz4：Git Source Lz4 Release：Git Release Lz4源码编译： 找到lz4\visual，可以选择VS2017和VS2010，本人使用的是VS2017 编译：会报一些.h找不到的错误，修改属性，VC++目录添加包含目录C:\Program Files (x86)\Windows Kits\10\Include\10.0.17134.0\ucrt和库目录C:\...
lz4压缩解压工具x64和x86
05-25
lz4 lz4解压 lz4压缩 cmd下可以运行
Lz4压缩算法学习
MarkusZhang的博客
06-05 2万+
lz4是目前基于综合来看效率最高的压缩算法，更加侧重于压缩解压缩速度，压缩比并不突出，本质上就是时间换空间。对于github上给出的lz4性能介绍：每核压缩速度大于500MB/s，多核CPU可叠加；它所提供的解码器也是极其快速的，每核可达GB/s量级。...
lz4压缩算法零修改移植
03-23
1、独立lz4压缩移植，零修改，只添加用户自定义文件lz4_user.c和lz4_user.h; 2、默认用的栈资源（速度快），可选用堆。# define LZ4_HEAPMODE 0; 3、默认用到栈大小为14k，若资源有限可调小。# define LZ4_MEMORY_...
lz4压缩算法源码
01-21
lz4压缩算法源码 LZ4 is a lossless data compression algorithm that is focused on compression and decompression speed
LZ4压缩算法集合包
06-25
3. **文档**：文档通常包含LZ4算法的基本原理、使用方法、API参考以及可能遇到的问题解决方案。这对于初学者快速上手和有经验的开发者深入研究都是非常有价值的。通过阅读文档，用户可以学习如何正确地在不同场景下...
lz4所有版本.zip
01-16
LZ4是一种高效的数据压缩算法，广泛应用于存储和传输领域，尤其在大数据处理和云计算环境中。这个"lz4所有版本.zip"压缩包包含了Python的LZ4库的多个版本，特别是针对Windows系统的版本，这对于那些在Windows环境下...
LZ4压缩算法简介
rayylee
08-18 4874
lz77编码思想：它是一种基于字典的算法，它将长字符串（也可以称为匹配项或者短语）编码成短小的标记，用小标记代替字典中的短语，也就是说，它通过用小的标记来代替数据中多次重复出现的长字符串来达到数据压缩的目的。其处理的符号不一定是文本字符，也可以是其他任意大小的符号。............
lz4压缩格式-block
shuxiaohua的博客
04-16 4161
概述 lz4属于lz77系列的压缩算法，lz77系列压缩算法将重复的字符串（也称为匹配）表示成（offset、match length）来对数据进行压缩。lz77算法只是一种思想，寻找匹配的方式有很多中，常见的有hash chain、BST，这些算法会在介绍各个通用压缩算法的时候介绍。 本文只介绍lz4的压缩格式，详细的算法实现会放在另外文章里面讲。 lz4实现了两种格式，分别叫block、fra...
LZ4格式及算法
最新发布
luopandeng的专栏
03-11 344
B.Checksum 表示每个block 是否包含checksum。LZ4 就是直接利用lz77替换之后编码， 不使用huffman。EndMark后面的checksum。Data 压缩块由多个序列组成，序列快的压缩，解压过程参考。
速度之王 — LZ4压缩算法（二）
weixin_30662539的博客
12-19 1175
LZ4(Extremely Fast Compression algorithm) 项目：http://code.google.com/p/lz4/ 作者：Yann Collet 本文作者：zhangskd @ csdn blog LZ4格式 The compressed block is composed of sequences. 每个数据块可以压缩成若干个序...
lz4 java 用法,LZ4参数详解
weixin_42374596的博客
03-13 2644
LZ4是一种压缩格式，特点是压缩/解压缩速度超快(虽然压缩率不咋地)，如果你特别在意压缩速度，或者当前环境的CPU资源紧缺，可以考虑这种格式。用法举例：压缩：lz4 abc.txt解压缩：lz4 abc.txt.lz4 -d管道用法，把ipcofig的输出定向到标准输出，再由LZ4压缩至文件abc.lz4：ipconfig | lz4 stdin abc.lz4最高压缩率，如果目标文件名存在，不提...
速度之王 — LZ4压缩算法（一）
weixin_30753873的博客
12-19 3637
LZ4(Extremely Fast Compression algorithm) 项目：http://code.google.com/p/lz4/ 作者：Yann Collet 本文作者：zhangskd @ csdn blog 简介 LZ4 is a very fast lossless compression algorithm, providing comp...
速度之王 — LZ4压缩算法（三）
热门推荐
zhangskd的专栏
12-19 2万+
LZ4是一个快速的无损压缩算法，单核的压缩速度超过400MB/s，单核的解压速度超过1GB/s。 LZ4也适用于多核的情况，压缩速度能成倍的提高，解压速度几乎达到RAM的速度限制。 文本主要分析LZ4的原理和实现。
LZ4压缩算法实现思路详解
08-15 1万+
最近遇到一个需求，需要使用LZ4的流式压缩来减少流量开销。笔者也是第一次接触LZ4算法，但速度之王的名声早已如雷贯耳。需求本身要求我使用go语言来编写一套LZ4压缩工具库，因为github上的go语言版本是残废的(它不支持流式压缩)，而CGO又会带来很多额外的开销(C栈和go栈的内存分布差距很大，有着很大的上下文切换开销)，于是我受命编写纯go版本的LZ4压缩工具库。 压缩的通用原理就是，假如当...
LZ4----优秀的压缩算法
koln频道
05-23 7626
https://blog.csdn.net/zhangskd/article/details/17009111https://github.com/lz4/lz4压缩率在1:4.5左右，速度为10ms级，如果压缩结果大于指定最大输出，压缩时间会长些，不过也在100ms左右。...
lz4工程目录压缩算法
08-09
LZ4 是一种高效的工程目录压缩算法，它通过使用了一些特定的技术和策略，有效地压缩工程目录的文件并减小文件的体积。 LZ4算法主要有以下几个特点： 1. 高压缩速度：LZ4算法的压缩速度非常快，可以以非常高的速度进行文件的压缩和解压缩操作。这对于处理大量文件和频繁的文件操作来说非常有优势。 2. 低延迟：LZ4算法的压缩和解压缩过程非常迅速，几乎没有延迟。这对于对性能要求较高的系统来说非常适用，可以提高系统的响应速度。 3. 高压缩率：虽然LZ4算法的压缩速度非常快，但它也能够达到较高的压缩率。通过使用一些特定的压缩技巧，LZ4算法可以有效地减小文件的体积，从而节省存储空间。 4. 零内存分配：LZ4算法在进行压缩和解压缩操作时，不需要进行额外的内存分配。这意味着在使用LZ4算法进行文件处理时，不会产生额外的内存开销，从而提高系统的效率。 总而言之，LZ4是一种非常高效的工程目录压缩算法，它具有高速压缩、低延迟、高压缩率和零内存分配等特点。在处理工程目录时，LZ4算法可以显著提高文件处理的效率和性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值