Snappy 快速压缩/解压库完整指南:性能原理、构建集成、API 用法与位流格式解析

原创2026-10-10 23:32:371,916 阅读
文章标签:序列化

Snappy 快速压缩/解压库完整指南:性能原理、构建集成、API 用法与位流格式解析

Snappy 是 Google 开源的压缩/解压库(本项目版本号见 CMakeLists.txt 的 project(Snappy VERSION 1.2.2)),其设计目标不是追求最高压缩率,而是在极高的压缩/解压速度与合理的压缩比之间取得平衡,被广泛用于 BigTable、MapReduce、内部 RPC 系统等对延迟敏感的存储与传输场景。本文以仓库根目录 README.md 为主干,结合 docs/README.md、snappy.h、snappy-c.h、format_description.txt、framing_format.txt 与相关源码/测试,系统讲解 Snappy 的定位、性能特征、构建方式、C++/C 两套 API、压缩位流格式、帧封装格式以及测试与基准工具的使用,读完即可在自有项目中完成集成、调参与验证。

一、Snappy 是什么:面向速度而非最大压缩率的 LZ77 库

Snappy 是一个压缩/解压库(snappy.cc 的实现以 LZ77 型字节编码为基础,详见 format_description.txt)。它不追求最大压缩率,也不承诺与其他压缩库的兼容性,而是瞄准"非常高的速度 + 合理的压缩率"这一目标组合。

README 明确给出了它与 zlib 的取舍关系:与 zlib 最快模式相比,Snappy 对大多数输入要快一个数量级(约 10 倍),但产出的压缩文件体积大约大 20%~100%。这意味着在吞吐优先、磁盘/网络带宽不是瓶颈的场景中,Snappy 往往比高压缩率的通用压缩器更合适。

README 归纳了它的四项核心属性:

属性 含义
Fast(快) 压缩速度可达 250 MB/sec 及以上,且不依赖汇编代码,完全用可移植的 C++ 实现
Stable(稳定) 已在 Google 生产环境中压缩/解压了 PB 级数据;位流格式(bitstream format)稳定,版本间不会变更
Robust(健壮) 解压器针对损坏或恶意输入做了防护设计,不会崩溃
Free and open source(自由开源) 采用 BSD 类许可证,详见仓库根目录 COPYING

此外,README 还透露了一个历史细节:Snappy 在部分 Google 演示材料中曾被称为 "Zippy"(docs/README.md 也确认了这一点)。

从源码角度看"稳健"并非空话:snappy_unittest.cc 中有专门的 CorruptedTest::VerifyCorrupted(见 snappy_unittest.cc),主动篡改压缩数据验证解压不崩溃;还通过 baddata1.snappy 等坏数据文件做回归测试(snappy_unittest.cc)。

二、性能特征:基准数字、压缩率与平台依赖

2.1 README 给出的基准数字

  • 单核 Core i7、64 位模式下:压缩约 250 MB/sec 及以上,解压约 500 MB/sec 及以上。
  • 这些数字针对的是基准套件中最慢的输入,其余输入通常更快。
  • 与同类算法(LZO、LZF、QuickLZ 等)相比,Snappy 通常更快,同时压缩比相当。

2.2 典型压缩率(基于内置基准套件)

输入类型 Snappy 压缩率 zlib 最快模式(同口径参考)
纯文本 约 1.5~1.7x 2.6~2.8x
HTML 约 2~4x 3~7x
JPEG / PNG 等已压缩数据 约 1.0x(基本无法再压缩) 1.0x

更复杂的算法能拿到更高压缩率,但通常以牺牲速度为代价。实际压缩比随输入内容波动很大,README 特别强调这一点——不要拿单一文件的结果外推到所有数据。

2.3 平台相关性与底层原因

Snappy 可移植性较好,但主要为 64 位 x86 兼容处理器优化,其他环境可能更慢。README 列出了三个关键原因:

  1. 大量使用 64 位运算:一次处理更多数据,减少指令数;
  2. 假设非对齐(unaligned)32/64 位读写代价很低:在需要逐字节模拟的平台上会显著变慢;
  3. 全程假设小端序(little-endian):在大端平台上多处需要字节交换(byte-swap)。

对应源码证据:snappy.h 中定义了 64 KB 压缩块 kBlockSize = 1 << 16 与哈希表尺寸范围 kMinHashTableSize = 1 << 8、kMaxHashTableSize = 1 << 15(见 snappy.h);CMakeLists.txt 通过 test_big_endian(SNAPPY_IS_BIG_ENDIAN) 在配置期检测字节序,供实现按平台切换路径。

三、构建:CMake 配置与编译产物

3.1 构建步骤

构建需要 CMake 版本满足 CMakeLists.txt 中的 cmake_minimum_required(VERSION 3.10)。README 给出的标准流程为:

git submodule update --init
mkdir build
cd build && cmake ../ && make
  • git submodule update --init 用于拉取 third_party/ 下的依赖(googletest 与 benchmark),分别支撑单元测试与微基准;
  • 项目要求 C++11(CMakeLists.txt,可作为子项目时被上层覆盖);
  • 默认同时构建库、测试与基准。

3.2 关键 CMake 选项

来自 CMakeLists.txt 的可配置项:

选项 默认值 说明
BUILD_SHARED_LIBS OFF 是否构建共享库(Windows 下为 DLL)
SNAPPY_BUILD_TESTS ON 是否构建 Snappy 自带的单元测试
SNAPPY_BUILD_BENCHMARKS ON 是否构建基准程序
SNAPPY_FUZZING_BUILD OFF 是否以模糊测试(fuzzing)方式构建
SNAPPY_REQUIRE_AVX / SNAPPY_REQUIRE_AVX2 OFF 是否要求目标处理器支持 AVX / AVX2 指令集
SNAPPY_INSTALL ON 是否安装头文件与库

配置期还会探测系统能力:检查 sys/mman.h、sys/uio.h 等头文件,并检测 zlib、LZO、LZ4 是否可用(CMakeLists.txt),用于 snappy_test_tool 的跨库对比。

3.3 构建产物

编译后除 libsnappy 库本体(add_library(snappy ""),见 CMakeLists.txt)外,还会生成三个辅助可执行文件(CMakeLists.txt):

  • snappy_unittest:单元测试;
  • snappy_test_tool:跨库对比基准工具;
  • snappy_benchmark:基于 Google Benchmark 的微基准。

这些工具只是开发辅助,集成到自有程序时不需要它们。

四、C++ 使用:从最简调用到高级接口

Snappy 的实现与主接口都用 C++ 编写(snappy.h 是主头文件)。集成方式:在调用文件中 #include "snappy.h",并与编译出的库链接即可。

4.1 最简用法(std::string 版)

README 给出的最简调用如下:

snappy::Compress(input.data(), input.size(), &output);
snappy::Uncompress(input.data(), input.size(), &output);

其中 input 与 output 均为 std::string。一个完整的可运行示例(补充了返回值检查与输出缓冲说明):

#include <cassert>
#include <string>
#include "snappy.h"

int main() {
  std::string input = "hello, snappy! hello, snappy! hello, snappy!";
  std::string output;

  // 压缩:返回写入的压缩字节数;输入长度 >= 2^32 时返回 0 且不写入任何内容
  size_t compressed_size = snappy::Compress(input.data(), input.size(), &output);
  assert(compressed_size > 0);

  std::string restored;
  // 解压:数据损坏时返回 false,不会崩溃
  bool ok = snappy::Uncompress(output.data(), output.size(), &restored);
  assert(ok);
  assert(restored == input);
  return 0;
}

4.2 更灵活的高级接口

README 提示"还有其他在各种方面更灵活的接口,包括对自定义(非数组)输入源的支持,详见头文件"。对应 snappy.h 中的接口族:

① Source/Sink 流式接口:基于 snappy-sinksource.h 中抽象的 Source(提供 Available/Peek/Skip)与 Sink(提供 Append/GetAppendBuffer 等)接口,可将压缩过程接入任意数据来源与去处(文件、网络、内存池等)。仓库自带 ByteArraySource 与 UncheckedByteArraySink 两个现成实现(snappy-sinksource.h)。底层入口在 snappy.cc 与 snappy.cc:

size_t Compress(Source* reader, Sink* writer);
size_t Compress(Source* reader, Sink* writer, CompressionOptions options);

② 原始字节数组接口(Raw 系列):适合对性能与内存控制要求高的场景,输出写入调用方预分配的缓冲区,缓冲区长度需至少为 snappy::MaxCompressedLength(input_length)(snappy.h),例如:

char* output = new char[snappy::MaxCompressedLength(input_length)];
size_t output_length;
snappy::RawCompress(input, input_length, output, &output_length);
// ... 处理 output ...
delete[] output;

③ 压缩级别 CompressionOptions:默认级别为 1(最快);级别 2 更慢但压缩率更好,当前标记为 EXPERIMENTAL,级别 3 及以上暂不支持,未来计划支持到 9(snappy.h)。头文件注释给出的对比口径:级别 1 相当于 LZ4 的 fast 模式(level 1),级别 2 相当于 LZ4 level 2,压缩率大致介于 zstd:-3 与 zstd:-2 之间,且解压速度通常比 snappy:1 与 zstd:-3 更快。C++ 中通过构造 snappy::CompressionOptions{2} 使用级别 2。

④ 可复用工作内存 CompressionContext:频繁压缩或希望避免堆分配时,可一次性创建 CompressionContext 并在多次 Compress()/RawCompress() 间复用;还支持把工作内存放到调用方提供的 workspace 中(此时库完全不做任何分配),详见 snappy.h 与实现 snappy.cc。注意:一个 context 只能被顺序使用,不得多线程并发使用。

4.3 C++ API 速查表(均声明于 snappy.h)

函数 用途 关键约束
Compress(input, len, &out[, options]) 字符串级压缩 输入 ≥ 2^32 字节时返回 0;input 不能与输出别名
CompressFromIOVec(iov, cnt, &out) 对 iovec 数组压缩 会先求和 iov 长度
Uncompress(compressed, len, &out) 字符串级解压 损坏数据返回 false
RawCompress(input, len, buf, &len) 数组级压缩 缓冲需 ≥ MaxCompressedLength
RawUncompress(compressed, len, buf) 数组级解压 损坏数据返回 false
MaxCompressedLength(n) 求压缩后最大长度 用于预分配
GetUncompressedLength(...) 读头部长度,O(1) 流可能被截断,需自行校验
IsValidCompressedBuffer(...) 校验缓冲区是否可解压 通常比真实解压快 4 倍以上
UncompressAsMuchAsPossible(...) 尽量解压到 sink 出错时可能只产出部分数据

五、C 接口:snappy-c.h 与状态码

想在 C 代码中使用 Snappy,可以直接使用仓库自带的 C 绑定 snappy-c.h(实现见 snappy-c.cc)。其核心是一个 snappy_status 枚举(snappy-c.h):

typedef enum {
  SNAPPY_OK = 0,
  SNAPPY_INVALID_INPUT = 1,
  SNAPPY_BUFFER_TOO_SMALL = 2
} snappy_status;

完整的压缩/解压流程示例(来自 snappy-c.h 的注释示例,整理为可直接使用的形式):

#include <stdlib.h>
#include "snappy-c.h"

/* 压缩 */
size_t output_length = snappy_max_compressed_length(input_length);
char* output = (char*)malloc(output_length);
if (snappy_compress(input, input_length, output, &output_length) == SNAPPY_OK) {
  /* ... 处理 output[0..output_length) ... */
}
free(output);

/* 解压:先用 snappy_uncompressed_length 得到目标长度,再分配 */
size_t ulen;
if (snappy_uncompressed_length(input, input_length, &ulen) == SNAPPY_OK) {
  char* uncompressed = (char*)malloc(ulen);
  if (snappy_uncompress(input, input_length, uncompressed, &ulen) == SNAPPY_OK) {
    /* ... 处理 uncompressed[0..ulen) ... */
  }
  free(uncompressed);
}

C 接口函数清单(snappy-c.h):

函数 说明
snappy_compress 压缩(固定使用级别 1),输出缓冲不足返回 SNAPPY_BUFFER_TOO_SMALL
snappy_compress_with_level 指定压缩级别(SNAPPY_MIN_COMPRESSION_LEVEL=1 ~ SNAPPY_MAX_COMPRESSION_LEVEL=2,见 snappy-c.h)
snappy_uncompress 解压,数据损坏返回非 SNAPPY_OK 值
snappy_max_compressed_length 求压缩输出最大长度,用于预分配
snappy_uncompressed_length O(1) 读取解压后长度(依据流头部)
snappy_validate_compressed_buffer 校验压缩数据是否可解压,通常比真实解压快 4 倍以上

同样地,输入长度 ≥ 2^32 时 snappy_compress 返回 SNAPPY_INVALID_INPUT 且 compressed_length 置 0。

六、压缩位流格式:Literals 与三种 Copy(format_description.txt)

仓库根目录 format_description.txt 是 Snappy 压缩格式的说明文档。要点如下。

6.1 整体结构

  • Snappy 是 LZ77 型、固定字节编码的压缩器:没有熵编码后端,也没有帧(framing)层——帧封装由上层系统负责。
  • 流由前导(preamble)+ 元素序列组成;元素只有两类:字面量(Literal) 与 拷贝(Copy,即回退引用),元素顺序没有限制,但流自然不能以 Copy 开头(两个连续字面量虽非最优,但完全合法)。
  • 每个元素以 1 个 tag 字节开始,其低 2 位指示元素类型:
tag 低 2 位 类型
00 Literal(字面量)
01 Copy with 1-byte offset
10 Copy with 2-byte offset
11 Copy with 4-byte offset

6.2 前导:解压后长度(varint)

流以解压后总长度开头,最大 2^32 - 1,以小端序 varint 存储:每个字节低 7 位为数据,最高位为 1 表示后续还有字节。例如:

  • 长度 64 → 0x40;
  • 长度 2097150(0x1FFFFE)→ 0xFE 0xFF 0x7F;
  • 由于最大值为 2^32-1,5 个字节足以编码任意合法长度。

GetUncompressedLength / snappy_uncompressed_length 就是 O(1) 解析这段前导。注意头部可能被截断或与实际不符,README 及 snappy.h 都提示调用方需自行承担校验责任。

6.3 Literal(00)的编码

  • 长度 ≤ 60 字节:tag 字节高 6 位直接存 (len-1),字面量紧随其后;
  • 长度 > 60 字节:(len-1) 以小端序存储在 tag 之后,tag 高 6 位取 60/61/62/63 分别表示长度占 1/2/3/4 字节,随后才是字面量本身。

6.4 Copy 的三种编码

Copy 编码两个值:offset(回退多少字节读取)与 length(拷贝多少字节)。offset 为 0 可被编码但不合法;回退超过当前解压位置的引用同样非法。与多数 LZ77 压缩器一样,length 可以大于 offset,从而形成行程编码(RLE)效果,例如 "xababab" 可编码为:

<literal: "xab"> <copy: offset=2 length=4>

三种 Copy 元素(format_description.txt):

类型 可编码长度范围 可编码 offset 范围 布局
1 字节 offset(01) 4~11 0~2047(11 bit:高 3 位在 tag 的 [5..7],低 8 位在后续 1 字节) tag 的 [2..4] 存 (len-4)
2 字节 offset(10) 1~64 0~65535 tag 高 6 位存 (len-1),后跟小端 16 位 offset
4 字节 offset(11) 同 2 字节(1~64) 32 位整数 tag 高 6 位存 (len-1),后跟小端 32 位 offset

实现细节:当前压缩器以 32 KB 为块工作且不做跨块匹配,因此不会产生超过约 32768 的 offset;但格式文档与 snappy.h 都强调解压器不应依赖这一点(历史上存在更大块的数据,也不排除未来变化)。当前实现块大小常量在 snappy.h(kBlockLog = 16),解压端仍须容忍长回退引用。

七、帧封装格式:面向流式传输与完整性校验(framing_format.txt)

README 提到的 framing_format.txt 描述了一种可选的帧格式,用于把 Snappy 数据封装进文件或流中,支持流式解压(无需整流驻留内存),并提供数据校验和。它不属于 Snappy 核心规范,当前官方分发不含实现,但多种第三方移植(如 Java、Node.js、Python、Smalltalk 等)实现了它。

7.1 通用结构与文件标识

  • 文件由一个个 chunk 紧密排列组成,无填充:每个 chunk = 1 字节 chunk 类型标识 + 3 字节小端长度(0~16777215)+ 数据,4 字节头部不计入长度。
  • 第一个 chunk 必须是流标识 chunk;流以文件结束为终点,没有显式的 EOF 标记。
  • 推荐标识(未正式注册,仅作参考,用于区分 raw 数据与 framed 数据):
标识 值
文件扩展名 .sz
MIME 类型 application/x-snappy-framed
HTTP Content-Encoding x-snappy-framed

7.2 校验和:掩码 CRC-32C

部分 chunk 携带校验和,格式为掩码后的 CRC-32C(CRC-32C 定义见 RFC 3720 第 12.1 节)。掩码方案与 Apache Hadoop 相同:校验和先循环右移 15 位,再加常量 0xa282ead8,等价于(framing_format.txt):

uint32_t mask_checksum(uint32_t x) {
  return ((x >> 15) | (x << 17)) + 0xa282ead8;
}

掩码可逆,校验和固定以 4 字节小端存储。掩码的目的是避免"数据与其自身校验和"互相干扰的问题。

7.3 Chunk 类型一览

类型字节 名称 说明
0xff 流标识 必须是流首元素,固定 6 字节内容 "sNaPpY",即流总是以 0xff 0x06 0x00 0x00 0x73 0x4e 0x61 0x50 0x70 0x59 开头;后续重复出现时可直接忽略(便于无重帧拼接文件)
0x00 压缩数据 内含普通 Snappy 压缩位流,数据前有未压缩数据的掩码 CRC-32C;数据部分最大 16777211 字节,且约定未压缩数据 ≤ 65536 字节,方便消费端使用小型定长缓冲
0x01 未压缩数据 允许直接发送原始数据(例如检测到不可压缩数据时),同样前置掩码 CRC-32C,最多 65536 字节,含校验和的最大合法 chunk 长度为 65540
0xfe 填充(Padding) 用于把流总字节数凑成外部要求(如某倍数);填充字节应为 0,解压器不得解释或校验填充内容
0x02~0x7f 保留·不可跳过 为将来扩展保留;解码器遇到必须立即报错(假定无法正确解码)
0x80~0xfd 保留·可跳过 同样保留,但解码器遇到必须跳过并继续解码

帧格式"只提供数据校验和、不提供元数据校验和",因此无法防御所有形式的截断(例如整块 chunk 缺失)。

八、测试与基准:三个配套工具的正确用法

编译 Snappy 时会额外生成三个二进制(README 指出:使用压缩库本身并不需要它们,但对开发很有用)。

8.1 snappy_benchmark——性能微基准

包含用于调优压缩/解压性能的微基准,基于 third_party/benchmark(Google Benchmark)实现。从 snappy_benchmark.cc 可见,它会遍历 snappy_test_data.h 中定义的测试数据文件清单 × 压缩级别 1/2 组合逐一评测。

8.2 snappy_unittest——正确性验证

单元测试,验证在各种场景下本机上的正确性,由 GoogleTest 驱动(third_party/googletest)。除常规的压缩/解压往返校验外,值得关注的是健壮性测试族:

  • CorruptedTest::VerifyCorrupted:主动篡改压缩字节,验证不崩溃(snappy_unittest.cc);
  • 读取 testdata/baddata1.snappy、baddata2.snappy、baddata3.snappy 三个坏数据文件,验证解压器不会返回疯狂长度、不会崩溃(snappy_unittest.cc);
  • SnappyCorruption 系列:TruncatedVarint、UnterminatedVarint、OverflowingVarint 等,覆盖截断/未终止/溢出的 varint 前导(snappy_unittest.cc)。

注意 README 的提醒:baddata[1-3].snappy 不是基准数据,仅用于单元测试中的损坏数据验证。

8.3 snappy_test_tool——跨库对比基准

可以对 Snappy 与若干其他压缩库做对比评测,条件是这些库在 configure 时被检测到(当前 CMake 检测 zlib、LZO、LZ4,见 CMakeLists.txt)。用法(README 原文):在命令行上先给出想对比的压缩算法(例如 --zlib),再给出一个或多个文件名:

./snappy_test_tool --zlib --lzo --lz4 --snappy testdata/alice29.txt testdata/urls.10K

从 snappy_test_tool.cc 可见其支持的开关:--zlib、--lzo、--lz4、--snappy(默认均开启),--bytes(每个文件用于计时的字节数,默认 10485760),--write_compressed / --write_uncompressed(把压缩/解压结果写到 <file>.comp / <file>.uncomp),以及 --start_len / --end_len 等。测量逻辑会对每个输入分块、多次运行并取中位数(snappy_test_tool.cc),输出格式类似:

snappy : [b 64M] bytes 152089 -> 83938 55.2%  comp 450.1 MB/s  uncomp 890.3 MB/s

8.4 测试数据目录 testdata/

testdata/ 目录包含微基准所用的文件,覆盖文本、HTML、URL、PDF、JPEG、protobuf 数据等不同形态(清单见 snappy_test_data.h),可作为相对均衡的基准起点。例如:alice29.txt、asyoulik.txt(纯文本)、html / html_x_4(HTML)、urls.10K(URL 列表)、paper-100k.pdf、fireworks.jpeg(已压缩数据,压缩比约为 1.0x)、geo.protodata(结构化二进制)。

九、周边生态:多语言绑定与典型使用场景

docs/README.md 提供了 README 之外的生态信息:

  • Snappy 在 Google 内部被广泛使用,从 BigTable、MapReduce 到内部 RPC 系统;
  • 除 C++ 实现与 C 绑定外,社区维护了多种语言的绑定/移植,包括:C#(Snappy for .NET、Snappy.NET、Snappy.Sharp)、C 移植、Common Lisp、Erlang、Go、Haskell、Haxe、Java(snappy-java 等,部分含帧格式实现)、Lua、Node.js(含帧格式)、Perl、PHP、Python(含帧格式命令行工具)、R、Ruby、Rust、Smalltalk 等;
  • 这些绑定与移植是第三方维护的,接入时请以各项目自身的文档为准;
  • 在开源软件中,Snappy 被用作存储/传输压缩方案或可选项,典型如 MongoDB、Cassandra、Couchbase、Hadoop、LevelDB(被 Google Chrome 使用)、Lucene、VoltDB 等(信息同样来自 docs/README.md 的列举,非本文评测结论)。

对需要流式传输 Snappy 数据(例如经 HTTP 流式发送)的场景,framing_format.txt 描述的帧格式就是为此设计;官方实现虽未包含,但上文列出的若干绑定(Java/Node.js/Python/Smalltalk 等)提供了帧格式实现可参考。

十、参与贡献的边界(Contributing 部分)

README 末尾的贡献指南明确了项目愿意接受的演进方向,也划定了边界:

  1. 支持 C++11;
  2. 编译器以 Clang 为主(gcc 与 MSVC 为 best-effort);
  3. 允许为以下平台做低层优化(汇编或等价 intrinsics):x86、x86-64、ARMv7(32 位)、ARMv8(AArch64);
  4. 只支持 format_description.txt 描述的 Snappy 压缩方案本身;
  5. 构建系统为 CMake。

超出上述核心范围的特性或依赖可能不会被接受;仓库维护方明确表示不太可能接受构建配置文件(如 CMakeLists.txt)的修改——其目标是维持 Google 内部少数受支持配置的可测试性,而非无限扩展操作系统、编译器或构建系统组合。有疑问可先到 Snappy 讨论邮件列表沟通(链接见 README.md)。若你打算优化 Snappy,README 建议务必先运行测试与基准,确认没有破坏任何东西。

十一、关联文档与关键源码速览

目的 路径
项目总览与使用入口 README.md
生态、绑定与使用案例 docs/README.md
C++ API 与压缩选项 snappy.h
C API snappy-c.h
Source/Sink 抽象 snappy-sinksource.h
核心实现 snappy.cc
压缩位流格式规范 format_description.txt
帧封装格式规范 framing_format.txt
构建配置与选项 CMakeLists.txt
单元测试 snappy_unittest.cc
微基准 snappy_benchmark.cc
跨库对比工具 snappy_test_tool.cc
测试数据清单 snappy_test_data.h
测试数据文件 testdata
许可证 COPYING

小结:Snappy 的价值在于"以可移植的纯 C++ 换来极致的吞吐、稳定的位流格式和抗损坏的解压器"。集成时按 snappy.h 的 Compress/Uncompress 即可快速上手;追求吞吐上限时改用 RawCompress/RawUncompress 配合 MaxCompressedLength 预分配,并用 CompressionContext 复用工作内存;需要流式传输与完整性校验时,可基于 framing_format.txt 自行或借助第三方绑定实现帧封装;最终请用 snappy_benchmark 与 snappy_unittest 在你的目标平台与真实数据上完成验证。

登录后查看全文
snappy