谁研究过传输过程中，对数据进行实时压缩的问题，请发表点看法

[小传]

因为数据传输中，很少有一个文件一个文件传输的，大都是一个包一个包的传输，或者是读文件的一部分进行传输，所以不知道用哪种快而好的压缩算法了。
原来用zlib,但发现速度慢而且压缩率也低

[小贵子]

压缩率是否高,还和你压缩什么内容有关的.比如压二进制内容,像音视频就比较低.但文本内容就很高

我也用zlib来压一些文本,感觉还不错啊

比如我解压近7百KB左右的压缩文件(原文件可能有5M多),耗时在100ms左右(硬件配置:T61)

2008/10/22 小传 <baiyu...@gmail.com>

因为数据传输中，很少有一个文件一个文件传输的，大都是一个包一个包的传输，或者是读文件的一部分进行传输，所以不知道用哪种快而好的压缩算法了。
原来用zlib,但发现速度慢而且压缩率也低

--
一把锋利的宝剑，要经过无数次的磨炼，才从愚钝走向飘逸

[小传]

我用ZLIB压缩并发送一个180M的EXE文件，每500K一压缩发送，结果发现，传输了165M。压缩耗费时间占用了50%以上。
AQTIME测的

[XiongJia Le]

文件一个包一个包一发,也是从 文件头开始压缩的...只压一个包会增加每次 zstream 的 init 和 finish 的次数会变慢的...

zstream 本来就设计成流方式的,很适合一个包一个包发送

2008/10/22 小贵子 <xgz...@gmail.com>:

[吴德建]

改成一次压缩完后再分批传送试试！

2008/10/22 小传 <baiyu...@gmail.com>

[小贵子]

这有一个取舍的问题:

1.传输流量(效率)

2.cpu消耗

如果你很在意传输流量的话,你可以压缩传输.这样传输效率会高一些.但如果压缩比很小,就要考虑耗费cpu来换取传输速度,是否值得.

你可以说下项目需求是什么,也许可以出些主意

2008/10/22 吴德建 <aga...@gmail.com>

--
一把锋利的宝剑，要经过无数次的磨炼，才从愚钝走向飘逸

[Feng Yu]

改用lzo压缩 速度和压缩率比较平衡

2008/10/22 小贵子 <xgz...@gmail.com>:

--
专注 高性能 容错 分布服务器的实现（erlang）
http://mryufeng.javaeye.com

[han]

看到关于数据压缩的问题的讨论。对于这方面不是很了解，但是想在传输时用数据
压缩。
我想问问，zlib压缩速度和压缩比怎么样。除了zlib，有没有比它更好的，压缩速
度又快，压缩比又高的。
希望大家能推荐一个效率高的开源的压缩库。

[Jiahua Huang]

2008/10/29 han <windows....@gmail.com>:

要速度的话， 可以 zlib 压缩等级调低。

或选用 lzop 之类追求速度的 zip 变种

[ledwinka]

lzo的压缩率对比zip没有什么优势吧，速度上确实不错

On 10月24日, 下午5时59分, "Feng Yu" <mryuf...@gmail.com> wrote:
> 改用lzo压缩 速度和压缩率比较平衡
>
> 2008/10/22 小贵子 <xgz...@gmail.com>:
>
>
>
> > 这有一个取舍的问题:
> > 1.传输流量(效率)
> > 2.cpu消耗
> > 如果你很在意传输流量的话,你可以压缩传输.这样传输效率会高一些.但如果压缩比很小,就要考虑耗费cpu来换取传输速度,是否值得.
> > 你可以说下项目需求是什么,也许可以出些主意
>
> > 2008/10/22 吴德建 <aga...@gmail.com>
>
> >> 改成一次压缩完后再分批传送试试！
>

> >> 2008/10/22 小传 <baiyuan...@gmail.com>

[ledwinka]

通用压缩的话，我觉得7z的压缩率蛮高的，不过速度比较慢，做实时压缩传输的话要看cpu够不够强劲了

[eSX]

Lz*系列算法有很多变种，譬如Lz77 Lzss等等，分别对时间、压缩比进行了一些权衡。
你可以自己斟酌。
至于现在很多成熟的压缩算法，都是变种于LZ系列算法，分别做了不同的改进。
而像很多成熟的传输方式，如http、rsync等都使用了gzip进行了压缩，相信选择gzip
还是有原因的。
另外你可以使用多种压缩方式，两边协商使用哪种压缩算法。
如下是ZFS文件系统使用的LZJB压缩算法，用于文件的压缩存储的，压缩比比较低，但
是速度很快。



/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/

/*
* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/

#pragma ident "@(#)lzjb.c 1.3 07/03/22 SMI"

/*
* We keep our own copy of this algorithm for 2 main reasons:
* 1. If we didn't, anyone modifying common/os/compress.c would
* directly break our on disk format
* 2. Our version of lzjb does not have a number of checks that the
* common/os version needs and uses
* In particular, we are adding the "feature" that compress() can
* take a destination buffer size and return -1 if the data will not
* compress to d_len or less.
*/

#include <sys/types.h>

#define MATCH_BITS 6
#define MATCH_MIN 3
#define MATCH_MAX ((1 << MATCH_BITS) + (MATCH_MIN - 1))
#define OFFSET_MASK ((1 << (16 - MATCH_BITS)) - 1)
#define LEMPEL_SIZE 256

/*ARGSUSED*/
size_t
lzjb_compress(void *s_start, void *d_start, size_t s_len, size_t d_len, int
n)
{
uchar_t *src = s_start;
uchar_t *dst = d_start;
uchar_t *cpy, *copymap;
int copymask = 1 << (NBBY - 1);
int mlen, offset;
uint16_t *hp;
uint16_t lempel[LEMPEL_SIZE]; /* uninitialized; see above */

while (src < (uchar_t *)s_start + s_len) {
if ((copymask <<= 1) == (1 << NBBY)) {
if (dst >= (uchar_t *)d_start + d_len - 1 - 2 *
NBBY) {
if (d_len != s_len)
return (s_len);
mlen = s_len;
for (src = s_start, dst = d_start; mlen;
mlen--)
*dst++ = *src++;
return (s_len);
}
copymask = 1;
copymap = dst;
*dst++ = 0;
}
if (src > (uchar_t *)s_start + s_len - MATCH_MAX) {
*dst++ = *src++;
continue;
}
hp = &lempel[((src[0] + 13) ^ (src[1] - 13) ^ src[2]) &
(LEMPEL_SIZE - 1)];
offset = (intptr_t)(src - *hp) & OFFSET_MASK;
*hp = (uint16_t)(uintptr_t)src;
cpy = src - offset;
if (cpy >= (uchar_t *)s_start && cpy != src &&
src[0] == cpy[0] && src[1] == cpy[1] && src[2] ==
cpy[2]) {
*copymap |= copymask;
for (mlen = MATCH_MIN; mlen < MATCH_MAX; mlen++)
if (src[mlen] != cpy[mlen])
break;
*dst++ = ((mlen - MATCH_MIN) << (NBBY - MATCH_BITS))
|
(offset >> NBBY);
*dst++ = (uchar_t)offset;
src += mlen;
} else {
*dst++ = *src++;
}
}
return (dst - (uchar_t *)d_start);
}

/*ARGSUSED*/
int
lzjb_decompress(void *s_start, void *d_start, size_t s_len, size_t d_len,
int n)
{
uchar_t *src = s_start;
uchar_t *dst = d_start;
uchar_t *d_end = (uchar_t *)d_start + d_len;
uchar_t *cpy, copymap;
int copymask = 1 << (NBBY - 1);

while (dst < d_end) {
if ((copymask <<= 1) == (1 << NBBY)) {
copymask = 1;
copymap = *src++;
}
if (copymap & copymask) {
int mlen = (src[0] >> (NBBY - MATCH_BITS)) +
MATCH_MIN;
int offset = ((src[0] << NBBY) | src[1]) &
OFFSET_MASK;
src += 2;
if ((cpy = dst - offset) < (uchar_t *)d_start)
return (-1);
while (--mlen >= 0 && dst < d_end)
*dst++ = *cpy++;
} else {
*dst++ = *src++;
}
}
return (0);